home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / cli / kill277.lha / Kill.c next >
Encoding:
C/C++ Source or Header  |  1995-01-24  |  8.9 KB  |  358 lines
  1. /*
  2. ** $VER: Kill.c 2.105 (24.1.95)
  3. **
  4. ** Beinahe dasselbe wie C:Delete, nur daß man zusätzlich wie bei
  5. ** List SINCE und UPTO angeben kann
  6. ** (und das Programm informativer ist (bei löschgeschützten Files))
  7. **
  8. ** (W) 1994/95 by Walter Dörwald
  9. */
  10.  
  11. BEGFOLD // Includes
  12. #include <exec/memory.h>
  13. #include <dos/datetime.h>
  14. #include <clib/macros.h>
  15. #include <proto/exec.h>
  16. #include <proto/dos.h>
  17. #include <proto/intuition.h>
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21.  
  22. #include <privat/Defs.h>
  23. #include <privat/Auto.h>
  24. #include <privat/Proto.h>
  25.  
  26. #include <debug/debug.h>
  27.  
  28. // !!! Wo ist denn dieses FORMAT_DEF definiert? (in dos.library/StrToDate() ist's jedenfalls dokumentiert)
  29. #define FORMAT_DEF 4
  30.  
  31. #include "rev.h"
  32. ENDFOLD
  33.  
  34. BEGFOLD // Defines
  35. #define PROGRAM "Kill"
  36.  
  37. #define ARG_TEMPLATE "FILE/M/A,ALL/S,QUIET/S,FORCE/S,SINCE/K,UPTO/K,SINCEDAYS/K/N,UPTODAYS/K/N,BIGGER/K/N,SMALLER/K/N,PLAIN/S,ANSI/S"
  38. #define ARG_FILE         0
  39. #define ARG_ALL          1
  40. #define ARG_QUIET        2
  41. #define ARG_FORCE        3
  42. #define ARG_SINCE        4
  43. #define ARG_UPTO         5
  44. #define ARG_SINCEDAYS    6
  45. #define ARG_UPTODAYS     7
  46. #define ARG_BIGGER       8
  47. #define ARG_SMALLER      9
  48. #define ARG_PLAIN       10
  49. #define ARG_ANSI        11
  50. #define ARG_sizeof      12
  51.  
  52. #define BOLD_STR CSI_STR "1m"
  53. #define NORM_STR CSI_STR "0m"
  54. ENDFOLD
  55.  
  56. BEGFOLD // Variablen
  57. static const char Version[] = "$VER: " PROGRAM " " VERSION_STR "." REVISION_STR " (" HEUTE_STR ")";
  58.  
  59. struct RDArgs *ArgsPtr;
  60. UBYTE *ArgArray[ARG_sizeof];
  61.  
  62. struct DateStamp Jetzt;
  63. struct DateStamp Since;
  64. struct DateStamp Upto;
  65. struct DateStamp SinceDays;
  66. struct DateStamp UptoDays;
  67.  
  68. BOOL UseANSIFlag;
  69. ENDFOLD
  70.  
  71. BEGFOLD BOOL INLINE IsDir(struct AnchorPath *AP)
  72. {
  73.     if ((AP->ap_Info.fib_DirEntryType >= 0) && (AP->ap_Info.fib_DirEntryType != ST_SOFTLINK))
  74.         return (TRUE);
  75.     else
  76.         return (FALSE);
  77. }
  78. ENDFOLD
  79.  
  80. BEGFOLD BOOL INLINE UseANSI(void)
  81. {
  82.     if (ArgArray[ARG_PLAIN])
  83.         return (FALSE);
  84.     else if (ArgArray[ARG_ANSI])
  85.         return (TRUE);
  86.     else
  87.         return ((BOOL)IsInteractive(Output()));
  88. }
  89. ENDFOLD
  90.  
  91. BEGFOLD void DoExit(ULONG result)
  92. {
  93.     if (ArgsPtr)
  94.         FreeArgs(ArgsPtr);
  95.  
  96.     exit(result);
  97. } 
  98. ENDFOLD
  99.  
  100. BEGFOLD void PrintError(LONG Error,STRPTR Text)
  101. {
  102.     D2(bug("Error=%ld, Text=»%s«\n",Error,Text));
  103.  
  104.     if (!ArgArray[ARG_QUIET])
  105.     {
  106.         if (!PrintFault(Error,Text))
  107.             Printf("%s: Error %ld",Text,Error);
  108.     }
  109. } 
  110. ENDFOLD
  111.  
  112. BEGFOLD LONG Kill(struct AnchorPath *AP)
  113. {
  114.     LONG Error;
  115.  
  116.     D2(bug("AP.ap_Buf=»%s«\n",AP->ap_Buf));
  117.     if (!ArgArray[ARG_QUIET])
  118.         Printf("%s",AP->ap_Buf);
  119.  
  120.     if (AP->ap_Info.fib_Protection & FIBF_DELETE) // Beim löschgeschützten Files vorher entriegeln
  121.     {
  122.         if (ArgArray[ARG_FORCE]) // ... aber nur wenn es der Benutzer auch will
  123.         {
  124.             if (SetProtection(AP->ap_Info.fib_FileName,AP->ap_Info.fib_Protection & ~FIBF_DELETE))
  125.             {
  126.                 if (!ArgArray[ARG_QUIET])
  127.                 {
  128.                     if (UseANSIFlag)
  129.                         Printf(" " BOLD_STR "unprotected" NORM_STR " and");
  130.                     else
  131.                         Printf(" unprotected and");
  132.                 }
  133.             }
  134.             else
  135.             {
  136.                 D(bug("SetProtection() fehlgeschlagen\n"));
  137.                 if (UseANSIFlag)
  138.                     PrintError(IoErr()," " BOLD_STR "not" NORM_STR " unprotected");
  139.                 else
  140.                     PrintError(IoErr()," not unprotected");
  141.                 return (RETURN_ERROR);
  142.             }
  143.         }
  144.         else
  145.         {
  146.             SetIoErr(ERROR_DELETE_PROTECTED);
  147.             if (UseANSIFlag)
  148.                 PrintError(ERROR_DELETE_PROTECTED," " BOLD_STR "not" NORM_STR " deleted (use FORCE/S)");
  149.             else
  150.                 PrintError(ERROR_DELETE_PROTECTED," not deleted (use FORCE/S)");
  151.             return (RETURN_WARN);
  152.         }
  153.     }
  154.     if (DeleteFile(AP->ap_Info.fib_FileName))
  155.     {
  156.         if (!ArgArray[ARG_QUIET])
  157.             Printf(" deleted\n");
  158.         return (RETURN_OK);
  159.     }
  160.     else
  161.     {
  162.         D(bug("DeleteFile() fehlgeschlagen\n"));
  163.         Error = IoErr();
  164.         if (UseANSIFlag)
  165.             PrintError(Error," " BOLD_STR "not" NORM_STR " deleted");
  166.         else
  167.             PrintError(Error," not deleted");
  168.         return ((Error == ERROR_DIRECTORY_NOT_EMPTY) ? RETURN_WARN : RETURN_ERROR);
  169.     }
  170. }
  171. ENDFOLD
  172.  
  173. BEGFOLD LONG Do(struct AnchorPath *AP)
  174. {
  175.     if (ArgArray[ARG_SINCE] && (CompareDates(&Since,&AP->ap_Info.fib_Date)<0))
  176.     {
  177.         D2(bug("AP.ap_Buf=»%s« to old (SINCE/K) (DateStamp=={%ld,%ld,%ld})\n",AP->ap_Buf,AP->ap_Info.fib_Date.ds_Days,AP->ap_Info.fib_Date.ds_Minute,AP->ap_Info.fib_Date.ds_Tick));
  178.         return (RETURN_OK);
  179.     }
  180.     if (ArgArray[ARG_UPTO] && (CompareDates(&Upto,&AP->ap_Info.fib_Date)>0))
  181.     {
  182.         D2(bug("AP.ap_Buf=»%s« to new (UPTO/K) (DateStamp=={%ld,%ld,%ld})\n",AP->ap_Buf,AP->ap_Info.fib_Date.ds_Days,AP->ap_Info.fib_Date.ds_Minute,AP->ap_Info.fib_Date.ds_Tick));
  183.         return (RETURN_OK);
  184.     }
  185.     if (ArgArray[ARG_SINCEDAYS] && (CompareDates(&SinceDays,&AP->ap_Info.fib_Date)<0))
  186.     {
  187.         D2(bug("AP.ap_Buf=»%s« to old (SINCEDAYS/K) (DateStamp=={%ld,%ld,%ld})\n",AP->ap_Buf,AP->ap_Info.fib_Date.ds_Days,AP->ap_Info.fib_Date.ds_Minute,AP->ap_Info.fib_Date.ds_Tick));
  188.         return (RETURN_OK);
  189.     }
  190.     if (ArgArray[ARG_UPTODAYS] && (CompareDates(&UptoDays,&AP->ap_Info.fib_Date)>0))
  191.     {
  192.         D2(bug("AP.ap_Buf=»%s« to new (UPTODAYS/K) (DateStamp=={%ld,%ld,%ld})\n",AP->ap_Buf,AP->ap_Info.fib_Date.ds_Days,AP->ap_Info.fib_Date.ds_Minute,AP->ap_Info.fib_Date.ds_Tick));
  193.         return (RETURN_OK);
  194.     }
  195.     if (ArgArray[ARG_BIGGER] && !IsDir(AP) && (AP->ap_Info.fib_Size<=*(LONG *)ArgArray[ARG_BIGGER]))
  196.     {
  197.         D2(bug("AP.ap_Buf=»%s« to small (BIGGER) (Size==%ld)\n",AP->ap_Buf,AP->ap_Info.fib_Size));
  198.         return (RETURN_OK);
  199.     }
  200.     if (ArgArray[ARG_SMALLER] && !IsDir(AP) && (AP->ap_Info.fib_Size>=*(LONG *)ArgArray[ARG_SMALLER]))
  201.     {
  202.         D2(bug("AP.ap_Buf=»%s« to big (SMALLER) (Size==%ld)\n",AP->ap_Buf,AP->ap_Info.fib_Size));
  203.         return (RETURN_OK);
  204.     }
  205.  
  206.     return (Kill(AP));
  207. } 
  208. ENDFOLD
  209.  
  210. BEGFOLD // Flags für Scan
  211. // Alle Unterverzeichnisse durchlaufen
  212. #define SB_ALL 0
  213. #define SF_ALL (1L<<SB_ALL)
  214.  
  215. // Alle Ausgaben unterdrücken
  216. #define SB_QUIET 1
  217. #define SF_QUIET (1L<<SB_QUIET)
  218. ENDFOLD
  219.  
  220. BEGFOLD LONG Scan(STRPTR *Files,LONGBITS BreakBits,LONGBITS Flags,LONG NameLen)
  221. {
  222.     struct AnchorPath *AP;
  223.     LONG               Error;
  224.     LONG               Level;
  225.     LONG               TestLevel;
  226.  
  227.     Level = RETURN_OK;
  228.  
  229.     if (AP = AllocVec(sizeof(struct AnchorPath)+NameLen,MEMF_ANY|MEMF_CLEAR))
  230.     {
  231.         AP->ap_BreakBits = BreakBits;
  232.         AP->ap_FoundBreak = 0;
  233.         AP->ap_Flags = APF_DOWILD;
  234.         AP->ap_Strlen = NameLen;
  235.  
  236.         for (;*Files;Files++)
  237.         {
  238.             for (Error = MatchFirst(*Files,AP);!Error;Error = MatchNext(AP))
  239.             {
  240.                 BPTR OldLock;
  241.  
  242.                 D2(bug("File »%s«, DateStamp {%ld,...}\n",AP->ap_Buf,AP->ap_Info.fib_Date.ds_Days));
  243.  
  244.                 if (AP->ap_Flags & APF_DIDDIR) // Directory fertig?
  245.                     AP->ap_Flags &= ~APF_DIDDIR;
  246.                 else if (IsDir(AP)) // Ein Directory?
  247.                 {
  248.                     if (Flags & SF_ALL) // Rein in's Directory aber noch nicht löschen sondern erst bei Rückkehr
  249.                     {
  250.                         AP->ap_Flags |= APF_DODIR;
  251.                         continue;
  252.                     }
  253.                 }
  254.  
  255.                 OldLock = CurrentDir(AP->ap_Current->an_Lock);
  256.  
  257.                 TestLevel = Do(AP);
  258.                 Level = MAX(Level,TestLevel);
  259.  
  260.                 CurrentDir(OldLock);
  261.                 if (Level>RETURN_WARN)
  262.                     goto fertig;
  263.             }
  264.             MatchEnd(AP);
  265.             // Den Fehlerlevel zurückgeben
  266.             if (Error!=ERROR_NO_MORE_ENTRIES)
  267.                 Level = RETURN_ERROR;
  268.         }
  269.     }
  270.     else
  271.     {
  272.         D(bug("AllocVec() fehlgeschlagen: Kein Speicher für struct AnchorPath\n"));
  273.         return (RETURN_FAIL);
  274.     }
  275.     fertig:
  276.     FreeVec(AP);
  277.     return (Level);
  278. } 
  279. ENDFOLD
  280.  
  281. BEGFOLD void main()
  282. {
  283.     LONG Level;
  284.     LONG Flags;
  285.     struct DateTime Zeit;
  286.  
  287.     DateStamp(&Jetzt);
  288.  
  289.     CLEARVAR(Zeit);
  290.     Zeit.dat_Format = FORMAT_DEF;
  291.     //Zeit.dat_Flags = 0; // DTF_SUBST braucht laut dos.library/StrToDate() nicht gesetzt zu sein
  292.  
  293.     if (!(ArgsPtr = ReadArgs(ARG_TEMPLATE,(LONG *)&ArgArray,NULL)))
  294.     {
  295.         D(bug("ReadArgs() fehlgeschlagen\n"));
  296.         PrintFault(IoErr(),PROGRAM "(parsing arguments)");
  297.         DoExit(RETURN_ERROR);
  298.     }
  299.  
  300.     Flags = 0L;
  301.     if (ArgArray[ARG_ALL])
  302.         Flags |= SF_ALL;
  303.     if (ArgArray[ARG_QUIET])
  304.         Flags |= SF_QUIET;
  305.     if (ArgArray[ARG_SINCE])
  306.     {
  307.         Zeit.dat_StrDate = ArgArray[ARG_SINCE];
  308.         if (!StrToDate(&Zeit))
  309.         {
  310.             D(bug("StrToDate() fehlgeschlagen (bei ARG_SINCE)\n"));
  311.             PrintFault(ERROR_OBJECT_WRONG_TYPE,PROGRAM "(parsing SINCE/K)");
  312.             DoExit(RETURN_ERROR);
  313.         }
  314.         Zeit.dat_Stamp.ds_Minute = 0;
  315.         Zeit.dat_Stamp.ds_Tick = 0;
  316.         Since = Zeit.dat_Stamp;
  317.  
  318.         D2(bug("Since=={%ld,%ld,%ld}\n",Since.ds_Days,Since.ds_Minute,Since.ds_Tick));
  319.     }
  320.     if (ArgArray[ARG_UPTO])
  321.     {
  322.         Zeit.dat_StrDate = ArgArray[ARG_UPTO];
  323.         if (!StrToDate(&Zeit))
  324.         {
  325.             D(bug("StrToDate() fehlgeschlagen (bei ARG_UPTO)\n"));
  326.             PrintFault(ERROR_OBJECT_WRONG_TYPE,PROGRAM "(parsing UPTO/K)");
  327.             DoExit(RETURN_ERROR);
  328.         }
  329.         Zeit.dat_Stamp.ds_Minute = 24*60-1;
  330.         Zeit.dat_Stamp.ds_Tick = TICKS_PER_SECOND-1;
  331.         Upto = Zeit.dat_Stamp;
  332.  
  333.         D2(bug("Upto=={%ld,%ld,%ld}\n",Upto.ds_Days,Upto.ds_Minute,Upto.ds_Tick));
  334.     }
  335.     if (ArgArray[ARG_SINCEDAYS])
  336.     {
  337.         SinceDays = Jetzt;
  338.         SinceDays.ds_Days += *(LONG *)ArgArray[ARG_SINCEDAYS];
  339.  
  340.         D2(bug("SinceDays=={%ld,%ld,%ld}\n",SinceDays.ds_Days,SinceDays.ds_Minute,SinceDays.ds_Tick));
  341.  
  342.     }
  343.     if (ArgArray[ARG_UPTODAYS])
  344.     {
  345.         UptoDays = Jetzt;
  346.         UptoDays.ds_Days += *(LONG *)ArgArray[ARG_UPTODAYS];
  347.  
  348.         D2(bug("UptoDays=={%ld,%ld,%ld}\n",UptoDays.ds_Days,UptoDays.ds_Minute,UptoDays.ds_Tick));
  349.     }
  350.     UseANSIFlag = UseANSI();
  351.  
  352.     if ((Level = Scan((STRPTR *)ArgArray[ARG_FILE],SIGBREAKF_CTRL_C,Flags,256L))>RETURN_WARN)
  353.         PrintFault(IoErr(),PROGRAM);
  354.  
  355.     DoExit(Level);
  356. } 
  357. ENDFOLD
  358.